KUNJUNGI KAMI

KUNJUNGI KITA DI BUKALAPAK, TOKOPEDIA DAN SHOPEE

Cara Kerja Sensor PIR HC-SR501 & Menghubungkannya dengan Arduino

 


Apakah kamu ingin membangun alarm keamanan rumah atau kamera jejak, atau mungkin kamu ingin membangunkan hiasan Halloween yang bergerak ketika anak-anak datang berkeliling meminta permen ke pintu kamu, maka kamu pasti harus mempertimbangkan untuk mendapatkan sensor Pasif Inframerah (PIR) HC-SR501.

Sensor PIR memungkinkan kamu untuk mendeteksi ketika seseorang atau hewan bergerak masuk atau keluar dari jangkauan sensor. Sensor ini adalah apa yang akan kamu temukan dalam sebagian besar sistem keamanan modern, sakelar lampu otomatis, pembuka pintu garasi, dan aplikasi serupa di mana kita ingin merespons gerakan.

Sebelum masuk ke detail lebih lanjut, mari kita pahami dulu bagaimana sebenarnya cara kerja sensor PIR."

Bagaimana cara kerja sensor PIR?


Semua objek, termasuk tubuh manusia, pada suhu di atas nol mutlak (0 Kelvin / -273,15 °C) memancarkan energi panas dalam bentuk radiasi inframerah. Semakin panas suatu objek, semakin banyak radiasi yang dipancarkannya. Radiasi ini tidak terlihat oleh mata manusia karena dipancarkan pada panjang gelombang inframerah. Sensor PIR dirancang khusus untuk mendeteksi tingkat radiasi inframerah seperti ini.

Sensor PIR terdiri dari dua bagian utama:"

1. Sebuah sensor piroelektrik, yang dapat Anda lihat dalam gambar di bawah ini sebagai logam bundar dengan kristal berbentuk persegi di tengahnya.

2. Sebuah lensa khusus yang disebut lensa fresnel yang mengarahkan sinyal inframerah ke sensor piroelektrik.



Sensor Piroelektrik

Sebuah sensor piroelektrik terdiri dari sebuah jendela dengan dua slot persegi panjang dan terbuat dari bahan (biasanya silikon berlapis) yang memungkinkan radiasi inframerah untuk melewatinya. Di belakang jendela, terdapat dua elektroda sensor inframerah terpisah, satu bertanggung jawab untuk menghasilkan output positif dan yang lainnya untuk menghasilkan output negatif.

Kedua elektroda dihubungkan sehingga saling menghapus satu sama lain. Hal ini karena kita mencari perubahan dalam tingkat IR dan bukan tingkat IR lingkungan. Itu sebabnya ketika satu bagian melihat lebih atau kurang radiasi IR daripada yang lain, kita mendapatkan output.


Ketika tidak ada pergerakan di sekitar sensor, kedua slot mendeteksi jumlah radiasi inframerah yang sama, menghasilkan sinyal output nol.

Tetapi ketika tubuh hangat seperti manusia atau hewan lewat, pertama-tama ia melintasi setengah dari sensor. Ini menyebabkan perubahan diferensial positif antara kedua bagian. Ketika tubuh hangat melintasi setengah lain dari sensor (keluar dari wilayah sensor), kebalikannya terjadi, dan sensor menghasilkan perubahan diferensial negatif. Dengan membaca perubahan tegangan ini, gerakan terdeteksi."


Lensa Fresnel

Mungkin kamu merasa bahwa lensa Fresnel yang digunakan di sini sebenarnya tidak melakukan apa-apa. Faktanya, inilah yang meningkatkan jangkauan dan bidang pandang sensor PIR. Konstruksi yang ramping dan ringan serta kemampuan mengumpulkan cahaya yang sangat baik membuatnya sangat berguna untuk membuat PIR ukuran kecil namun kuat.

Sebuah lensa Fresnel terdiri dari serangkaian alur konsentrik yang digariskan pada plastik. Kontur-kontur ini bertindak sebagai permukaan pemfokusan individual, mengumpulkan sinar cahaya sejajar pada titik fokus. Akibatnya, lensa Fresnel, meskipun lebih kecil dalam ukuran, mampu memfokuskan cahaya secara serupa dengan lensa optik konvensional.



Sebenarnya, untuk meningkatkan jangkauan dan bidang pandang sensor PIR, lensa ini dibagi menjadi beberapa bagian fasit, setiap bagian adalah lensa Fresnel terpisah.


Fasit-fasit yang berbeda dan sub-lensa menciptakan berbagai area/zona deteksi yang saling tumpang tindih. Itulah mengapa pusat-pusat lensa 'tidak konsisten' pada gambar di atas - setiap satu menunjuk ke setengah berbeda dari elemen sensor PIR.


Ikhtisar Perangkat Sensor PIR HC-SR501

Untuk sebagian besar proyek Arduino kami yang memerlukan deteksi apakah seseorang telah keluar atau masuk ke dalam area, sensor PIR HC-SR501 adalah pilihan yang bagus. Ini memiliki konsumsi daya rendah, biaya rendah, mudah dihubungkan, dan sangat populer di kalangan hobiis.

Sensor PIR ini sendiri cukup sederhana dan dapat digunakan langsung. Cukup berikan daya 5V - 12V dan ground. Output sensor akan menjadi HIGH ketika mendeteksi gerakan dan menjadi LOW ketika tidak ada gerakan (tidak mendeteksi gerakan).

Dengan menghubungkan output ini ke mikrokontroler, kamu dapat merespons gerakan dengan menghidupkan/mematikan lampu, mengaktifkan kipas angin, mengaktifkan hiasan Halloween, atau bahkan mengambil gambar penyerbu.

Dan yang terbaik adalah bahwa sensor ini mengonsumsi kurang dari 2mA arus dan dapat mendeteksi gerakan hingga 7 meter (21 kaki) dengan kendali sensitivitas.

Pengendali PIR BISS0001

Di tengah modul ini terdapat IC pengendali pasif inframerah (PIR) - BISS0001. Karena kekebalan terhadap noise yang diberikannya, BISS0001 adalah salah satu pengendali PIR yang paling stabil yang tersedia.

Chip ini mengambil output dari sensor piroelektrik dan melakukan beberapa pemrosesan kecil untuk menghasilkan pulsa output digital.


Kamu dapat mempelajari lebih lanjut tentang BISS0001 dari lembar data.

Daya

Modul ini dilengkapi dengan regulator tegangan presisi 3.3V, sehingga dapat ditenagai oleh tegangan DC apa pun mulai dari 4.5 hingga 12 volt, meskipun umumnya menggunakan 5V.

Modul ini dilengkapi dengan dioda perlindungan (juga dikenal sebagai dioda keselamatan) untuk melindungi modul dari tegangan dan arus terbalik. Jadi, bahkan jika kamu secara tidak sengaja menghubungkan daya dengan polaritas yang salah, modul kamu tidak akan rusak.


Penyesuaian Sensitivitas

Sensor PIR memiliki potensiometer di bagian belakang untuk menyesuaikan sensitivitas.


Potensiometer ini mengatur jangkauan deteksi maksimum. Sensitivitas dapat diatur dalam rentang sekitar 3 meter hingga 7 meter. Namun, topologi ruanganmu dapat memengaruhi jangkauan sebenarnya yang kamu dapatkan. Memutar potensiometer searah jarum jam akan meningkatkan sensitivitas dan dengan demikian jangkauan, dan sebaliknya.


Penyesuaian Waktu Tunda

Ada potensiometer lain di belakang sensor PIR untuk menyesuaikan Waktu Tunda.


Potensiometer ini mengatur berapa lama output akan tetap HIGH setelah gerakan terdeteksi. Ini dapat diatur dari 1 detik hingga sekitar 3 menit. Memutar potensiometer searah jarum jam akan meningkatkan tunda, sementara memutar potensiometer berlawanan arah jarum jam akan mengurangi tunda.

Pemilihan Jumper Pemicu

Ada dua mode pemicu yang menentukan bagaimana sensor akan bereaksi ketika gerakan terdeteksi.

Mode Pemicu Tunggal: Gerakan yang konstan akan menyebabkan pemicu tunggal.
Mode Pemicu Ganda: Gerakan yang konstan akan menyebabkan serangkaian pemicu.

Papan ini dilengkapi dengan jumper berg (beberapa modul memiliki jumper jembatan solder) yang memungkinkan kamu memilih salah satu dari dua mode:


L – Memilih ini akan mengatur mode pemicu tunggal. Dalam mode ini, output menjadi HIGH segera setelah gerakan terdeteksi dan tetap HIGH selama periode yang ditentukan oleh potensiometer Waktu Tunda. Deteksi selanjutnya diblokir sampai output kembali ke LOW pada akhir waktu tunda. Jika masih ada gerakan, output akan menjadi HIGH lagi. Seperti yang bisa kamu lihat dalam gambar di bawah ini, Gerakan #3 sepenuhnya diabaikan.


H – Memilih ini akan mengatur mode pemicu ganda. Dalam mode ini, output menjadi HIGH segera setelah gerakan terdeteksi dan tetap HIGH selama periode yang ditentukan oleh potensiometer Waktu Tunda. Berbeda dengan mode pemicu tunggal, deteksi selanjutnya tidak diblokir, sehingga waktu tunda diatur ulang setiap kali gerakan terdeteksi. Begitu gerakan berhenti, output kembali ke LOW hanya setelah waktu tunda. Oleh karena itu, dinamakan mode pemicu ganda.



Komponen Opsional – Termistor dan LDR

Modul HC-SR501 memiliki pad solder untuk dua komponen tambahan. Biasanya, komponen ini diberi label 'RT' dan 'RL'. Perhatikan bahwa pada beberapa papan, labelnya mungkin tertutup oleh lensa Fresnel di sisi sebaliknya dari komponen.

RT – Koneksi ini adalah untuk termistor atau resistor sensitif suhu. Menambahkan ini memungkinkan HC-SR501 digunakan dalam suhu ekstrem. Ini juga meningkatkan akurasi detektor sejauh tertentu.

RL – Koneksi ini adalah untuk Resistor Terkendali Cahaya (LDR) atau Fotoresistor. Menambahkan komponen ini memungkinkan HC-SR501 beroperasi dalam kondisi gelap. Ini berguna untuk membangun sistem pencahayaan yang sensitif terhadap gerakan.

Komponen tambahan ini dapat disolder langsung ke modul atau diperpanjang ke lokasi jarak jauh menggunakan kabel dan konektor.

Berikut adalah spesifikasi teknisnya:

Overating Voltage 4.5 – 20V (typically 5V)
Maximum Current Draw < 2mA
Time Delay ~ 1 sec to 3 min
Detection Distance 3 – 7 meters (9 – 21 feet)
Detection Angle 120 degrees (typically)



Pemetaan Pin Sensor PIR HC-SR501


HC-SR501 memiliki konektor 3-pin. Tanda-tandanya tersembunyi oleh lensa Fresnel, jadi lihat gambar berikut untuk pemetaan pin.



Diagram Pemetaan Pin Sensor PIR Inframerah Pasif

VCC adalah pasokan daya untuk sensor ini. Anda dapat menghubungkan tegangan masukan di antara 5 hingga 12V ke pin ini, meskipun 5V biasanya digunakan.

Output pin adalah keluaran logika TTL 3,3V. Ini akan menjadi TINGGI ketika mendeteksi gerakan dan menjadi rendah saat tidak ada gerakan (idle).

GND adalah pin tanah.


Menggunakan Sensor PIR sebagai unit mandiri


Salah satu alasan mengapa sensor PIR HC-SR501 sangat populer adalah karena sensor ini sangat serbaguna dan mampu beroperasi sendiri. Anda dapat meningkatkan serbagainya lebih lanjut dengan menghubungkannya ke mikrokontroler seperti Arduino.

Untuk eksperimen pertama kami, kita akan menggunakan HC-SR501 untuk menunjukkan seberapa berguna sensor ini jika digunakan secara mandiri.

Kabel untuk eksperimen ini sangat sederhana. Hubungkan baterai ke VCC sensor dan GND, dan hubungkan LED merah kecil ke pin keluaran melalui resistor pembatas arus 220Ω. Itu saja!

Sekarang ketika PIR mendeteksi gerakan, pin keluaran akan menjadi "TINGGI" dan menyalakan LED!"
Ingatlah bahwa setelah kamu menyuplai daya ke rangkaian, kamu perlu menunggu 30-60 detik agar PIR beradaptasi dengan energi inframerah di ruangan. LED mungkin akan berkedip sedikit selama waktu tersebut. Tunggu sampai LED benar-benar mati dan kemudian berjalan di depannya atau mengayunkan tangan, dan amati LED menyala sesuai dengan gerakan tersebut.

Output PIR ini dapat dihubungkan langsung ke modul relay jika kamu ingin menghidupkan/mematikan sesuatu berdasarkan gerakan.

Menghubungkan Sensor PIR ke Arduino

Sekarang bahwa kita memiliki pemahaman lengkap tentang bagaimana sensor PIR bekerja, kita dapat mulai menghubungkannya ke Arduino kita!

Menghubungkan sensor PIR ke Arduino sangatlah sederhana. Beri daya PIR dengan 5V dan hubungkan ground ke ground. PIR berfungsi sebagai output digital, jadi yang perlu kamu lakukan adalah mendengarkan pin output-nya. Hubungkan output ke pin digital Arduino #8.

Untuk HC-SR501 agar berfungsi dengan benar, atur jumper ke posisi H (Mode Pemicu Ganda). Kamu juga perlu mengatur Waktu Tunda setidaknya 3 detik, putar potensiometer Waktu Tunda searah jarum jam sejauh mungkin. Terakhir, atur potensiometer sensitivitas ke posisi yang kamu inginkan atau, jika kamu tidak yakin, atur ke tengah.

Tabel berikut ini mencantumkan koneksi pin:

Gambar di bawah ini menunjukkan bagaimana menghubungkan sensor PIR HC-SR501 ke Arduino.




Sekarang kamu siap untuk mengunggah beberapa kode dan membuat sensor PIR bekerja.


Contoh Kode Arduino

Kode tersebut sangat sederhana. Pada dasarnya, kode hanya memantau apakah input ke pin #8 berada di posisi HIGH atau LOW.
 int ledPin = 13;                // choose the pin for the LED
int inputPin = 8;               // choose the input pin (for PIR sensor)
int pirState = LOW;             // we start, assuming no motion detected
int val = 0;                    // variable for reading the pin status
 
void setup() {
  pinMode(ledPin, OUTPUT);      // declare LED as output
  pinMode(inputPin, INPUT);     // declare sensor as input
 
  Serial.begin(9600);
}
 
void loop(){
  val = digitalRead(inputPin);  // read input value
  
  if (val == HIGH)	// check if the input is HIGH
  {            
    digitalWrite(ledPin, HIGH);  // turn LED ON
	
    if (pirState == LOW) 
	{
      Serial.println("Motion detected!");	// print on output change
      pirState = HIGH;
    }
  } 
  else 
  {
    digitalWrite(ledPin, LOW); // turn LED OFF
	
    if (pirState == HIGH)
	{
      Serial.println("Motion ended!");	// print on output change
      pirState = LOW;
    }
  }
}


Hal yang perlu dipertimbangkan sebelum merancang aplikasi berbasis PIR

Ketika merancang sistem berdasarkan HC-SR501, kamu perlu mempertimbangkan periode penundaan berikut ini.

Waktu Penutupan

Ketika output sensor menjadi LOW, itu akan tetap LOW selama sekitar 2 detik. Selama periode ini, deteksi gerakan terkunci.


Sebagai contoh, katakanlah kamu telah mengatur sensor untuk waktu tunda selama 4 detik dan mengatur jumper ke 'L'. Jadi ketika kamu mengayunkan tangan di depan sensor, output akan menjadi HIGH selama 4 detik dan kemudian menjadi LOW selama sekitar 2 detik. Semua gerakan dalam periode ini sepenuhnya diabaikan; seperti yang bisa kamu lihat, Gerakan #2 diabaikan di sini.

Penundaan Saat Menyalakan Daya

Seperti sebagian besar sensor PIR, HC-SR501 memerlukan sekitar 30 hingga 60 detik setelah dihidupkan untuk menjalani urutan inisialisasi. Pada saat itu, ia mempelajari tanda inframerah lingkungan sekitar. Pada dasarnya, ia melakukan kalibrasi terhadap lingkungannya untuk menentukan apa yang merupakan gerakan.

Pemicu palsu kemungkinan akan terjadi selama waktu kalibrasi ini, jadi semua pemicu selama waktu ini sebaiknya diabaikan. Pastikan juga bahwa tidak ada terlalu banyak pergerakan di depan sensor ketika sedang mengalami kalibrasi sendiri karena hal ini dapat mengganggu proses kalibrasi.

Referensi:
"How HC-SR501 PIR Sensor Works & Interface It With Arduino", Last Minute Engineer, https://lastminuteengineers.com/pir-sensor-arduino-tutorial/#google_vignette

Interfacing Modul Bluetooth HC-05 dengan NodeMCU

Interfacing Modul Bluetooth HC-05 dengan NodeMCU



Overview of Bluetooth


HC-05 Bluetooth Module 



HC-05 adalah perangkat Bluetooth yang digunakan untuk komunikasi nirkabel dengan perangkat yang mendukung Bluetooth (seperti ponsel pintar). Perangkat ini berkomunikasi dengan mikrokontroler menggunakan komunikasi serial (USART).

Perangkat ini menambahkan protokol komunikasi nirkabel ke dalam aplikasi tertanam sehingga dapat berkomunikasi dengan perangkat Bluetooth lainnya.

Perintah AT digunakan untuk mengontrol modul Bluetooth. Kita dapat mengubah pengaturannya seperti kata sandi, nama perangkat, pengaturan komunikasi USART seperti baud rate, jumlah bit stop atau paritas, dll.

Untuk informasi lebih lanjut tentang modul Bluetooth HC-05, pinnya, dan cara menggunakannya, lihat topik Modul Bluetooth HC-05 di bagian sensor dan modul.

NodeMCU berbasis ESP8266 memiliki modul komunikasi serial UART melalui mana ia dapat berkomunikasi dengan modul Bluetooth. Untuk mengetahui lebih lanjut tentang fungsi UART berbasis Lua pada NodeMCU, lihat NodeMCU UART dengan IDE ESPlorer.


Diagram Koneksi Modul Bluetooth HC-05 dengan NodeMCU 





Mengendalikan LED menggunakan Modul Bluetooth HC-05 dengan NodeMCU

Mari mengembangkan aplikasi kecil di mana kita dapat mengontrol LED ON-OFF melalui ponsel pintar.

Hal ini dilakukan dengan menghubungkan modul Bluetooth HC-05 dengan NodeMCU. Data dari HC-05 diterima/dikirim secara serial oleh NodeMCU.

Dalam aplikasi ini, ketika angka 1 dikirim dari ponsel pintar, LED akan menyala dan jika angka 2 dikirim, LED akan mati. Jika data yang diterima adalah selain 1 atau 2, itu akan mengirimkan pesan ke ponsel untuk memilih opsi yang benar.

Kita dapat menulis kode untuk NodeMCU DevKit dalam bahasa Skrip Lua atau bahasa C/C++. Kami menggunakan IDE ESPlorer untuk menulis kode dalam skrip Lua dan IDE Arduino untuk menulis kode dalam bahasa C/C++. Untuk informasi lebih lanjut, lihat Panduan Memulai dengan NodeMCU menggunakan IDE ESPlorer (yang menggunakan skrip Lua untuk NodeMCU) dan Panduan Memulai dengan NodeMCU menggunakan IDE Arduino (yang menggunakan sketsa Arduino berbasis bahasa C untuk NodeMCU).




LEDpin = 4

gpio.mode(LEDpin, gpio.OUTPUT)--set LED pin as output pin
gpio.write(LEDpin, gpio.LOW)-- set LED state initially low

--begin uart with specs
uart.setup(0, 9600, 8, uart.PARITY_NONE, uart.STOPBITS_1, 1)
--set callback function on receive to make decision about LED on/off
uart.on("data",1,
function(data)
    if(data == "1") then
        gpio.write(LEDpin, gpio.HIGH)
        print("LED ON")
    elseif(data == "2") then
        gpio.write(LEDpin, gpio.LOW)
        print("LED OFF")
    else
        print("select proper option") 
    end
end, 0)
Di bawah ini adalah respons yang diterima dari NodeMCU Bluetooth saat mengirim perintah dari contoh di atas pada terminal Bluetooth di ponsel pintar.

 

Selain itu, kita dapat menulis kode untuk contoh di atas dari Arduino IDE. Untuk mengetahui cara memulai penggunaan NodeMCU dengan Arduino IDE, lihat Panduan Memulai dengan NodeMCU menggunakan Arduino IDE.

Kode Bluetooth HC-05 untuk NodeMCU menggunakan Arduino

int LED = D4;

void setup() {
 pinMode(LED, OUTPUT);
 Serial.begin(9600); /* Define baud rate for serial communication */
}

void loop() {

 if (Serial.available())  /* If data is available on serial port */
    {
      char data_received; 
      data_received = Serial.read();  /* Data received from bluetooth */
      if (data_received == '1')
      {
       digitalWrite(LED, HIGH);
       Serial.write("LED turned ON\n");        
      }
      else if (data_received == '2')
      {
       digitalWrite(LED, LOW);
       Serial.write("LED turned OFF\n");
      }
      else
      {
       Serial.write("Select either 1 or 2");
      }
    }
}
end, 0)
Komponen yang digunakan

Modul Bluetooth HC-05 X1 DataSheet Beli
NodeMCU X1 DataSheet Beli
ESP12F X1 DataSheet Beli
LED 5mm X1 DataSheet Beli

Referensi: 
"HC-05 Bluetooth Module Interfacing with NodeMCU," ElectronicsWings, https://www.electronicwings.com/nodemcu/hc-05-bluetooth-module-interfacing-with-nodemcu

Menghasilkan Sinyal PWM dengan ESP32 Menggunakan Arduino IDE

Dalam tutorial ini, kami akan menunjukkan kepada Anda cara menghasilkan sinyal PWM dengan ESP32 menggunakan Arduino IDE. Sebagai contoh, kami akan membangun rangkaian sederhana yang memudarkan LED menggunakan pengendali PWM LED di ESP32. Kami juga akan menunjukkan kepada Anda bagaimana Anda dapat mendapatkan sinyal PWM yang sama pada pin GPIO yang berbeda pada saat yang bersamaan.


Sebelum melanjutkan dengan tutorial ini, Anda harus sudah menginstal add-on ESP32 di Arduino IDE Anda. Ikuti salah satu tutorial berikut untuk menginstal ESP32 di Arduino IDE, jika Anda belum melakukannya.


Bagian yang Diperlukan

Untuk mengikuti tutorial ini, Anda memerlukan komponen-komponen berikut:

Anda dapat menggunakan tautan-tautan sebelumnya atau pergi langsung ke tokopedia.com/cncstorebandung untuk menemukan semua komponen yang Anda butuhkan untuk proyek Anda dengan harga terbaik!


Kontroler PWM LED ESP32

ESP32 memiliki kontroler PWM LED dengan 16 saluran independen yang dapat dikonfigurasi untuk menghasilkan sinyal PWM dengan properti yang berbeda.

Berikut adalah langkah-langkah yang harus Anda ikuti untuk memudarkan LED dengan PWM menggunakan Arduino IDE:

1. Pertama, Anda perlu memilih saluran PWM. Terdapat 16 saluran dari 0 hingga 15.

2. Kemudian, Anda perlu mengatur frekuensi sinyal PWM. Untuk LED, frekuensi 5000 Hz sudah cukup baik digunakan.

3. Anda juga perlu mengatur resolusi siklus tugas sinyal: Anda memiliki resolusi dari 1 hingga 16 bit. Kami akan menggunakan resolusi 8 bit, yang berarti Anda dapat mengendalikan kecerahan LED menggunakan nilai dari 0 hingga 255.

4. Selanjutnya, Anda perlu menentukan pada pin GPIO atau beberapa GPIO mana sinyal akan muncul. Untuk itu, Anda akan menggunakan fungsi berikut:

ledcAttachPin(GPIO, channel)
5.Terakhir, untuk mengontrol kecerahan LED menggunakan PWM, Anda menggunakan fungsi berikut:
ledcWrite(channel, dutycycle)
Fungsi ini menerima sebagai argumen saluran yang menghasilkan sinyal PWM dan siklus tugas.

Pengendalian Kecerahan LED
Mari kita lihat contoh sederhana untuk melihat bagaimana menggunakan pengontrol PWM LED ESP32 menggunakan Arduino IDE.

Skema
Sambungkan sebuah LED ke ESP32 Anda seperti pada diagram skema berikut. LED harus terhubung ke GPIO 16.



Catatan: Anda dapat menggunakan pin apa pun yang Anda inginkan, selama itu dapat berfungsi sebagai output. Semua pin yang dapat berfungsi sebagai output dapat digunakan sebagai pin PWM. Untuk informasi lebih lanjut tentang GPIO ESP32, baca: Referensi Pinout ESP32: Pin GPIO mana yang sebaiknya Anda gunakan?

Kode

Buka Arduino IDE Anda dan salin kode berikut.
 // the number of the LED pin
const int ledPin = 16;  // 16 corresponds to GPIO16

// setting PWM properties
const int freq = 5000;
const int ledChannel = 0;
const int resolution = 8;
 
void setup(){
  // configure LED PWM functionalitites
  ledcSetup(ledChannel, freq, resolution);
  
  // attach the channel to the GPIO to be controlled
  ledcAttachPin(ledPin, ledChannel);
}
 
void loop(){
  // increase the LED brightness
  for(int dutyCycle = 0; dutyCycle &lt;= 255; dutyCycle++){   
    // changing the LED brightness with PWM
    ledcWrite(ledChannel, dutyCycle);
    delay(15);
  }

  // decrease the LED brightness
  for(int dutyCycle = 255; dutyCycle &gt;= 0; dutyCycle--){
    // changing the LED brightness with PWM
    ledcWrite(ledChannel, dutyCycle);   
    delay(15);
  }
}
Anda memulai dengan mendefinisikan pin tempat LED terpasang. Dalam hal ini, LED terpasang pada GPIO 16.
const int ledPin = 16;  // 16 corresponds to GPIO16
Di dalam fungsi setup(), Anda perlu mengonfigurasi PWM LED dengan properti yang telah Anda tentukan sebelumnya menggunakan fungsi ledcSetup() yang menerima sebagai argumen ledChannel, frekuensi, dan resolusi, seperti berikut:
ledcSetup(ledChannel, freq, resolution);
Selanjutnya, Anda perlu memilih GPIO tempat Anda akan mendapatkan sinyal tersebut. Gunakan fungsi ledcAttachPin() yang menerima sebagai argumen GPIO tempat Anda ingin mendapatkan sinyal, dan saluran yang menghasilkan sinyal. Dalam contoh ini, kami akan mendapatkan sinyal pada GPIO ledPin, yang sesuai dengan GPIO 16. Saluran yang menghasilkan sinyal adalah ledChannel, yang sesuai dengan saluran 0.
 ledcAttachPin(ledPin, ledChannel);
Di dalam loop, Anda akan mengubah siklus tugas antara 0 dan 255 untuk meningkatkan kecerahan LED.
 for(int dutyCycle = 0; dutyCycle &lt;= 255; dutyCycle++){
    // changing the LED brightness with PWM
    ledcWrite(ledChannel, dutyCycle);
    delay(15); 
}
Untuk mengatur kecerahan LED, Anda hanya perlu menggunakan fungsi ledcWrite() yang menerima sebagai argumen saluran yang menghasilkan sinyal, dan siklus tugas.
 ledcWrite(ledChannel, dutyCycle);
}
Karena kita menggunakan resolusi 8 bit, siklus tugas akan dikendalikan menggunakan nilai dari 0 hingga 255. Perhatikan bahwa dalam fungsi ledcWrite(), kita menggunakan saluran yang menghasilkan sinyal, dan bukan GPIO.

Pengujian Contoh

Unggah kode ke ESP32 Anda. Pastikan Anda telah memilih papan dan port COM yang benar. Lihat sirkuit Anda. Anda seharusnya memiliki LED pengatur cahaya yang meningkat dan mengurangi kecerahan.


Mendapatkan Sinyal yang Sama pada GPIO yang Berbeda

Anda dapat mendapatkan sinyal yang sama dari saluran yang sama pada berbagai GPIO yang berbeda. Untuk mencapainya, Anda hanya perlu menghubungkan GPIO tersebut ke saluran yang sama pada fungsi setup().

Mari modifikasi contoh sebelumnya untuk meredupkan 3 LED menggunakan sinyal PWM yang sama dari saluran yang sama.

Skema

Tambahkan dua LED tambahan ke sirkuit Anda dengan mengikuti diagram skematik berikut:




(Diagram skematik ini menggunakan versi modul ESP32 DEVKIT V1 dengan 30 GPIO - jika Anda menggunakan model lain, harap periksa pinout untuk papan yang Anda gunakan.)

Kode

Salin kode berikut ke Arduino IDE Anda.
 // the number of the LED pin
const int ledPin = 16;  // 16 corresponds to GPIO16
const int ledPin2 = 17; // 17 corresponds to GPIO17
const int ledPin3 = 5;  // 5 corresponds to GPIO5

// setting PWM properties
const int freq = 5000;
const int ledChannel = 0;
const int resolution = 8;
 
void setup(){
  // configure LED PWM functionalitites
  ledcSetup(ledChannel, freq, resolution);
  
  // attach the channel to the GPIO to be controlled
  ledcAttachPin(ledPin, ledChannel);
  ledcAttachPin(ledPin2, ledChannel);
  ledcAttachPin(ledPin3, ledChannel);
}
 
void loop(){
  // increase the LED brightness
  for(int dutyCycle = 0; dutyCycle &lt;= 255; dutyCycle++){   
    // changing the LED brightness with PWM
    ledcWrite(ledChannel, dutyCycle);
    delay(15);
  }

  // decrease the LED brightness
  for(int dutyCycle = 255; dutyCycle &gt;= 0; dutyCycle--){
    // changing the LED brightness with PWM
    ledcWrite(ledChannel, dutyCycle);   
    delay(15);
  }
}
}
Ini adalah kode yang sama dengan yang sebelumnya tetapi dengan beberapa modifikasi. Kami telah mendefinisikan dua variabel tambahan untuk dua LED baru, yang mengacu pada GPIO 17 dan GPIO 5.
const int ledPin2 = 17; // 17 corresponds to GPIO17 
const int ledPin3 = 5;  // 5 corresponds to GPIO5
Kemudian, dalam fungsi setup(), kami telah menambahkan baris-baris berikut untuk mengaitkan kedua GPIO dengan saluran 0. Ini berarti bahwa kita akan mendapatkan sinyal yang sama, yang dihasilkan pada saluran 0, pada kedua GPIO tersebut. 

Menguji Proyek

Unggah sketsa yang baru ke ESP32 Anda. Pastikan Anda telah memilih papan dan port COM yang benar. Sekarang, perhatikan sirkuit Anda:



Semua GPIO mengeluarkan sinyal PWM yang sama. Jadi, ketiga LED meningkat dan berkurang kecerahannya secara bersamaan, menghasilkan efek yang disinkronkan.



Penutup

Secara ringkas, dalam pos ini Anda telah mempelajari cara menggunakan pengontrol PWM LED ESP32 dengan Arduino IDE untuk mengatur kecerahan LED. Konsep yang dipelajari dapat digunakan untuk mengendalikan output lain dengan PWM dengan mengatur properti sinyal yang tepat.

SERVER WEB MOTOR SERVO ESP32 DENGAN ARDUINO IDE

Dalam tutorial ini, kami akan menunjukkan kepada Anda bagaimana membangun sebuah server web dengan ESP32 yang mengontrol posisi poros dari sebuah motor servo menggunakan slider. Pertama, kita akan melihat cara mengendalikan motor servo dengan ESP32, dan kemudian kita akan membangun server webnya.


Menghubungkan Motor Servo ke ESP32

Motor servo memiliki tiga kabel: daya, tanah (ground), dan sinyal. Biasanya, kabel daya berwarna merah, GND berwarna hitam atau coklat, dan kabel sinyal biasanya berwarna kuning, oranye, atau putih."

Kabel Warna
Daya Merah
GND Hitam, atau coklat
Sinyal Kuning, oranye, atau putih



Ketika menggunakan motor servo kecil seperti S0009 seperti yang ditunjukkan pada gambar di bawah ini, Anda dapat memberinya pasokan daya langsung dari ESP32."














Tetapi jika Anda menggunakan lebih dari satu motor servo atau jenis lainnya, Anda mungkin perlu memberi pasokan daya ke servo Anda menggunakan sumber daya eksternal.












Jika Anda menggunakan motor servo kecil seperti S0009, Anda perlu menghubungkan:


GND -> pin GND ESP32;

Daya -> pin VIN ESP32;

Sinyal -> GPIO 13 (atau salah satu pin PWM lainnya).

Catatan: dalam kasus ini, Anda dapat menggunakan salah satu GPIO ESP32, karena setiap GPIO dapat menghasilkan sinyal PWM. Namun, kami tidak merekomendasikan penggunaan GPIO 9, 10, dan 11 yang terhubung ke flash SPI terintegrasi dan tidak direkomendasikan untuk penggunaan lain.

Skema

Dalam contoh kami, kami akan menghubungkan kabel sinyal ke GPIO 13. Jadi, Anda dapat mengikuti diagram skema berikut untuk menghubungkan motor servo Anda.

















Skema ini menggunakan versi modul ESP32 DEVKIT V1 dengan 36 GPIO - jika Anda menggunakan model lain, harap periksa pinout untuk papan yang Anda gunakan.)


Bagaimana Mengendalikan Motor Servo?

Anda dapat mengatur posisi poros servo dalam berbagai sudut dari 0 hingga 180º. Servo dikendalikan menggunakan sinyal modulasi lebar pulsa (PWM). Ini berarti bahwa sinyal PWM yang dikirimkan ke motor akan menentukan posisi porosnya.



Untuk mengendalikan motor, Anda dapat menggunakan kemampuan PWM dari ESP32 dengan mengirimkan sinyal 50Hz dengan lebar pulsa yang sesuai. Atau Anda dapat menggunakan pLibrary untuk membuat tugas ini menjadi lebih sederhana.


Menyiapkan Arduino IDE

Ada add-on untuk Arduino IDE yang memungkinkan Anda untuk memprogram ESP32 menggunakan Arduino IDE dan bahasa pemrogramannya. Ikuti salah satu tutorial berikut untuk menyiapkan Arduino IDE Anda agar dapat bekerja dengan ESP32, jika Anda belum melakukannya.

Setelah memastikan Anda telah menginstal add-on ESP32, Anda dapat melanjutkan tutorial ini.


Menginstal ESP32_Arduino_Servo_Library

Library ESP32 Arduino Servo memudahkan pengendalian motor servo dengan ESP32 Anda, menggunakan Arduino IDE. Ikuti langkah-langkah berikut untuk menginstal library di Arduino IDE Anda:


  1. Klik di sini untuk mengunduh ESP32_Arduino_Servo_Library. Anda harus memiliki folder .zip di folder Unduhan Anda.
  2. Ekstrak folder .zip dan Anda akan mendapatkan folder ESP32-Arduino-Servo-Library-Master
  3. Ganti nama folder Anda dari ESP32-Arduino-Servo-Library-Master menjadi ESP32_Arduino_Servo_Library
  4. Pindahkan folder ESP32_Arduino_Servo_Library ke folder library instalasi Arduino IDE Anda
  5. Terakhir, buka kembali Arduino IDE Anda

Menguji Contoh

Setelah menginstal library, buka Arduino IDE Anda. Pastikan Anda telah memilih papan ESP32, lalu buka File > Contoh > ServoESP32 > Simple Servo.

/*********
  Rui Santos
  Complete project details at https://randomnerdtutorials.com  
  Written by BARRAGAN and modified by Scott Fitzgerald
*********/

#include 

Servo myservo;  // create servo object to control a servo
// twelve servo objects can be created on most boards

int pos = 0;    // variable to store the servo position

void setup() {
  myservo.attach(13);  // attaches the servo on pin 13 to the servo object
}

void loop() {
  for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
    // in steps of 1 degree
    myservo.write(pos);              // tell servo to go to position in variable 'pos'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
  for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
    myservo.write(pos);              // tell servo to go to position in variable 'pos'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
}


Memahami Kode

Sketsa ini memutar motor servo 180 derajat ke satu sisi, dan 180 derajat ke sisi lainnya. Mari kita lihat bagaimana cara kerjanya.


Pertama, Anda perlu menyertakan library Servo:


#include <Servo.h>
Kemudian, Anda perlu membuat sebuah objek servo. Dalam hal ini, objek tersebut dinamakan myservo.
Servo myservo;

Setup()

Dalam fungsi setup(), Anda menginisialisasi komunikasi serial untuk tujuan debugging, dan menghubungkan GPIO 13 ke objek servo."

void setup() {
  myservo.attach(13);
Loop()
Dalam loop(), kita mengubah posisi poros motor dari 0 hingga 180 derajat, dan kemudian dari 180 hingga 0 derajat. Untuk mengatur poros ke posisi tertentu, Anda hanya perlu menggunakan metode write() dalam objek servo. Anda mengirimkan sebagai argumen, sebuah angka integer dengan posisi dalam derajat."
Servo myservo;

Setup()

Dalam fungsi setup(), Anda menginisialisasi komunikasi serial untuk tujuan debugging, dan menghubungkan GPIO 13 ke objek servo."

myservo.write(pos);

Menguji Sketsa

Unggah kode ke ESP32 Anda. Setelah mengunggah kode, Anda seharusnya melihat poros motor berputar ke satu sisi dan kemudian ke sisi lainnya.

Membuat Server Web ESP32

Sekarang bahwa Anda tahu bagaimana mengendalikan servo dengan ESP32, mari buat server web untuk mengendalikannya (pelajari lebih lanjut tentang cara membangun Server Web ESP32). Server web yang akan kita bangun:

  • Mengandung slider dari 0 hingga 180, yang dapat Anda sesuaikan untuk mengontrol posisi poros servo;
  • Nilai slider saat ini secara otomatis diperbarui di halaman web, serta posisi poros, tanpa perlu merefresh halaman web. Untuk ini, kami menggunakan AJAX untuk mengirim permintaan HTTP ke ESP32 di latar belakang;
  • Mererefresh halaman web tidak mengubah nilai slider maupun posisi poros.



Membuat Halaman HTML


Mari mulai dengan melihat teks HTML yang perlu dikirimkan oleh ESP32 ke peramban Anda.

<!DOCTYPE html>
<html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="icon" href="data:,">
  <style>
    body {
      text-align: center;
      font-family: "Trebuchet MS", Arial;
      margin-left:auto;
      margin-right:auto;
    }
    .slider {
      width: 300px;
    }
  </style>
  <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
</head>
<body>
  <h1>ESP32 with Servo</h1>
  <p>Position: <span id="servoPos"></span></p>
  <input type="range" min="0" max="180" class="slider" id="servoSlider" onchange="servo(this.value)"/>
  <script>
    var slider = document.getElementById("servoSlider");
    var servoP = document.getElementById("servoPos");
    servoP.innerHTML = slider.value;
    slider.oninput = function() {
      slider.value = this.value;
      servoP.innerHTML = this.value;
    }
    $.ajaxSetup({timeout:1000});
    function servo(pos) {
      $.get("/?value=" + pos + "&");
      {Connection: close};
    }
  </script>
</body>
</html>

Membuat Slider
Halaman HTML untuk proyek ini melibatkan pembuatan slider. Untuk membuat slider dalam HTML, Anda menggunakan tag <input>. Tag <input> menentukan bidang di mana pengguna dapat memasukkan data.

Terdapat berbagai jenis input yang tersedia. Untuk mendefinisikan sebuah slider, gunakan atribut "type" dengan nilai "range". Dalam slider, Anda juga perlu mendefinisikan rentang minimum dan maksimum menggunakan atribut "min" dan "max".


<input type="range" min="0" max="180" class="slider" id="servoSlider" onchange="servo(this.value)"/&gt
Anda juga perlu mendefinisikan atribut lain seperti:

  • class untuk menggaya slider
  • id untuk memperbarui posisi saat ini yang ditampilkan pada halaman web
  • Dan akhirnya, atribut onchange untuk memanggil fungsi servo untuk mengirim permintaan HTTP ke ESP32 ketika slider bergerak.
   

Menambahkan JavaScript ke Berkas HTML

Selanjutnya, Anda perlu menambahkan beberapa kode JavaScript ke berkas HTML Anda dengan menggunakan tag <script> dan </script>. Potongan kode ini akan memperbarui halaman web dengan posisi slider saat ini:"
var slider = document.getElementById("servoSlider");
var servoP = document.getElementById("servoPos");
servoP.innerHTML = slider.value;
slider.oninput = function() {
slider.value = this.value;
servoP.innerHTML = this.value;
}value=" + pos + "&");
}
Dan baris-baris selanjutnya melakukan permintaan HTTP GET ke alamat IP ESP pada jalur URL tertentu /?value=[POSISI_SLIDER]&.

$.ajaxSetup({timeout:1000});
function servo(pos) {
$.get("/?value=" + pos + "&");
}
Sebagai contoh, ketika slider berada pada posisi 0, Anda melakukan permintaan HTTP GET pada URL berikut:
Dan ketika slider berada pada posisi 180 derajat, Anda akan memiliki sesuatu seperti ini:
Dengan cara ini, ketika ESP32 menerima permintaan GET, ia dapat mengambil parameter nilai dalam URL dan memindahkan motor servo ke posisi yang tepat.

Kode

Sekarang, kita perlu menyertakan teks HTML sebelumnya dalam sketsa dan memutar motor servo sesuai dengan posisinya. Sketsa berikut ini melakukan hal tersebut.

Catatan: seperti yang telah kita sebutkan sebelumnya, Anda perlu menginstal add-on ESP32 di Arduino IDE Anda. Ikuti salah satu panduan berikut untuk menginstal papan ESP32 di Arduino IDE, jika Anda belum melakukannya:


Instruksi Windows – Papan ESP32 di Arduino IDE
Instruksi Mac dan Linux – Papan ESP32 di Arduino IDE

Salin kode berikut ke Arduino IDE Anda, tetapi jangan mengunggahnya sekarang. Pertama, kita akan melihat bagaimana cara kerjanya."
Berikut adalah kode HTML yang telah ditandai dengan kotak warna abu untuk kode Arduino yang Anda berikan
  
/*********
Rui Santos
Complete project details at https://randomnerdtutorials.com
*********/
#include <WiFi.h>
#include <Servo.h>
Servo myservo; // create servo object to control a servo
// twelve servo objects can be created on most boards
// GPIO the servo is attached to
static const int servoPin = 13;
// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";
// Set web server port number to 80
WiFiServer server(80);
// Variable to store the HTTP request
String header;
// Decode HTTP GET value
String valueString = String(5);
int pos1 = 0;
int pos2 = 0;
// Current time
unsigned long currentTime = millis();
// Previous time
unsigned long previousTime = 0;
// Define timeout time in milliseconds (example: 2000ms = 2s)
const long timeoutTime = 2000;
void setup() {
Serial.begin(115200);
myservo.attach(servoPin); // attaches the servo on the servoPin to the servo object
// Connect to Wi-Fi network with SSID and password
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
// Print local IP address and start web server
Serial.println("");
Serial.println("WiFi connected.");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
server.begin();
}
void loop(){
WiFiClient client = server.available(); // Listen for incoming clients
if (client) { // If a new client connects,
currentTime = millis();
previousTime = currentTime;
Serial.println("New Client."); // print a message out in the serial port
String currentLine = ""; // make a String to hold incoming data from the client
while (client.connected() && currentTime - previousTime <= timeoutTime) { // loop while the client's connected
currentTime = millis();
if (client.available()) { // if there's bytes to read from the client,
char c = client.read(); // read a byte, then
Serial.write(c); // print it out the serial monitor
header += c;
if (c == '\n') { // if the byte is a newline character
// if the current line is blank, you got two newline characters in a row.
// that's the end of the client HTTP request, so send a response:
if (currentLine.length() == 0) {
// HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
// and a content-type so the client knows what's coming, then a blank line:
client.println("HTTP/1.1 200 OK");
client.println("Content-type:text/html");
client.println("Connection: close");
client.println();
// Display the HTML web page
client.println(""); client.println(""); client.println(""); // CSS to style the on/off buttons // Feel free to change the background-color and font-size attributes to fit your preferences client.println(""); client.println(""); // Web Page client.println("

ESP32 with Servo

"); client.println("

Position:

"); client.println(""); client.println(""); client.println("");
//GET /?value=180& HTTP/1.1
if(header.indexOf("GET /?value=")>=0) {
pos1 = header.indexOf('=');
pos2 = header.indexOf('&');
valueString = header.substring(pos1+1, pos2);
//Rotate the servo
myservo.write(valueString.toInt());
Serial.println(valueString);
}
// The HTTP response ends with another blank line
client.println();
// Break out of the while loop
break;
} else { // if you got a newline, then clear currentLine
currentLine = "";
}
} else if (c != '\r') { // if you got anything else but a carriage return character,
currentLine += c; // add it to the end of the currentLine
}
}
}
// Clear the header variable
header = "";
// Close the connection
client.stop();
Serial.println("Client disconnected.");
Serial.println("");
}
}
Cara Kerja Kode
Pertama, kita menyertakan libarary Servo, dan membuat objek servo yang disebut myservo.

#include
Servo myservo; // create servo object to control a servo
Kita juga membuat variabel untuk menyimpan nomor GPIO yang terhubung ke servo. Dalam kasus ini, GPIO 13.

const int servoPin = 13;
Jangan lupa bahwa Anda perlu memodifikasi dua baris berikut untuk menyertakan kredensial jaringan Anda.
// Replace with your network credentials const char* ssid = "";
const char* password = "";
Kemudian, buat beberapa variabel yang akan digunakan untuk mengekstrak posisi slider dari permintaan HTTP.
// Decode HTTP GET value
String valueString = String(5);
int pos1 = 0;
int pos2 = 0;
setup()
Dalam setup(), Anda perlu menghubungkan servo ke GPIO yang terhubung dengannya, dengan menggunakan myservo.attach().
myservo.attach(servoPin); // attaches the servo on the servoPin to the servo object

Bagian pertama dari loop() membuat server web dan mengirimkan teks HTML untuk menampilkan halaman web. Kami menggunakan metode yang sama yang telah kami gunakan dalam proyek server web ini.

Bagian berikut dari kode mengambil nilai slider dari permintaan HTTP."
//GET /?value=180& HTTP/1.1
if(header.indexOf("GET /?value=") >= 0) {
pos1 = header.indexOf('=');
pos2 = header.indexOf('&');
valueString = header.substring(pos1 + 1, pos2);
}
Ketika Anda menggerakkan slider, Anda membuat permintaan HTTP pada URL berikut yang berisi posisi slider antara tanda = dan & 

Anda dapat menandai URL HTTP tersebut dalam HTML seperti berikut:
http://your-esp-ip-address/?value=[SLIDER_POSITION]&
Nilai posisi slider disimpan dalam variabel valueString.

Kemudian, kita mengatur servo ke posisi tertentu tersebut menggunakan myservo.write() dengan variabel valueString sebagai argumen. Variabel valueString adalah string, jadi kita perlu menggunakan metode toInt() untuk mengonversinya menjadi angka bulat - tipe data yang diterima oleh metode write()."
myservo.write(valueString.toInt());
Menguji Server Web
Sekarang Anda dapat mengunggah kode ke ESP32 Anda - pastikan Anda telah memilih papan yang benar dan port COM yang benar. Juga jangan lupa untuk memodifikasi kode untuk menyertakan kredensial jaringan Anda.

Setelah mengunggah kode, buka Serial Monitor pada kecepatan baud 115200.
Tekan tombol "Enable" pada ESP32 untuk me-restart papan, dan salin alamat IP ESP32 yang muncul di Serial Monitor.

Buka peramban Anda, tempelkan alamat IP ESP, dan Anda akan melihat halaman web yang telah Anda buat sebelumnya. Geser slider untuk mengontrol motor servo.



Di Serial Monitor, Anda juga dapat melihat permintaan HTTP yang Anda kirimkan ke ESP32 ketika Anda menggerakkan slider.



Eksperimenlah dengan server web Anda untuk melihat apakah semuanya berfungsi dengan baik.


Penutup

Secara ringkas, dalam tutorial ini Anda telah belajar cara mengendalikan motor servo dengan ESP32 dan cara membuat server web dengan slider untuk mengontrol posisinya.

Ini hanyalah contoh bagaimana mengendalikan motor servo. Alih-alih slider, Anda dapat menggunakan bidang input teks, beberapa tombol dengan sudut-sudut yang telah ditentukan, atau bidang input lain yang sesuai.

Referensi : 
"ESP32 Servo Motor Web Server with Arduino IDE", Random Nerd Tutorial, https://randomnerdtutorials.com/esp32-servo-motor-web-server-arduino-ide/